function MyAjaxRules(fnVerMensaje,fnVerMensajeModal,fnOcultarMensaje, debugMode, fnLog) {
    
    if (typeof fnVerMensaje  === "function") {
        this.fnVerMensaje = fnVerMensaje;   
    }
    
    if (typeof fnVerMensajeModal  === "function") {
        this.fnVerMensajeModal = fnVerMensajeModal;
    }
    
    if (typeof fnOcultarMensaje  === "function") {
        this.fnOcultarMensaje = fnOcultarMensaje;
    }
    
    if (typeof fnLog  === "function") {
        this.fnLog = fnLog;
    }
        
    this.debugMode = debugMode;
}

MyAjaxRules.prototype.TIPOS_BLOQUEO = {
    DIRECTO: "DIRECTO", 
    INDIRECTO: "INDIRECTO",
    BIDIRECCIONAL: "BIDIRECCIONAL",//El que se aplica por defecto en la reglas de bloqueo
    EXCLUSIVO: "EXCLUSIVO",
    SIN_BLOQUEO: "SIN_BLOQUEO" //El que se aplica por defecto cuando NO hay reglas definidas
}

MyAjaxRules.prototype.debugMode = false;
MyAjaxRules.prototype.DEFAULT_PALABRA_BLOQUEO = "DEFAULT_PALABRA_BLOQUEO";
MyAjaxRules.prototype.DEFAULT_SEPERADOR_PALABRAS = /\b\s+/;


//MyAjaxRules.prototype.numProcesos = 0; No es necesaria porque coincide con this.myAjaxRulesObjects.length
MyAjaxRules.prototype.myAjaxRulesObjects = new Array();
MyAjaxRules.prototype.MAX_AJAX_TIMEOUT = 30000;
MyAjaxRules.prototype.TIPICAL_AJAX_TIMEOUT = 25000;

MyAjaxRules.prototype.puedoEjecutarAjax = function (params, evitarMensajeAlerta) { 
    var self = this;
    var hayBloqueo = false;
    params.log = "\n*** COMIENZO EVALUACIÓN ***";
    
    if (params.tipoBloqueo == this.TIPOS_BLOQUEO.SIN_BLOQUEO) { 
        
        return true;
    } 
    
    if (params.tipoBloqueo === this.TIPOS_BLOQUEO.EXCLUSIVO && this.myAjaxRulesObjects.length > 0) {
        params.log = "\n*** FIN EVALUACION BLOQUEADO = true  por bloqueo EXCLUSIVO***";
        hayBloqueo = true;                         
        mostrarMensajeBloqueo();
    }
    
    if (!hayBloqueo && params.palabraBloqueo) {          
        hayBloqueo = comprobarBloqueo();            
    }
    
    
    return !hayBloqueo;
    
    function comprobarBloqueo() {        
        
        var estaBloqueado = self.myAjaxRulesObjects.some(
            function(object, index) {                
                var permiteAjax = true;  
                var reglas = object.reglasBloqueo;
                
                //Bloqueo Directo                
                if (reglas.length > 0) { 
                    params.log += "\n----COMIENZO EVALUACIÓN REGLA OBJETO AJAX " + index + "---";
                    params.log += "\nEvaluación de bloqueos directos";                    
                    if (object.modoPermisivo === true) {
                        params.log += "\nEvaluación en modo permisivo";
                        permiteAjax = reglas.some (
                            function (cadena) {                            
                                var rdo = pasaRegla(params, cadena, self.TIPOS_BLOQUEO.DIRECTO, params.selectorThis);
                                params.log += "\nResultado de la evaluación permitir en modo permisivo " + rdo ;
                                return rdo;
                            }
                            );
                    
                    } else {
                        params.log += "\nEvaluación en modo no permisivo";
                        permiteAjax = reglas.every (
                            function (cadena) {                            
                                var rdo = pasaRegla(params, cadena, self.TIPOS_BLOQUEO.DIRECTO, params.selectorThis);
                                params.log += "\nResultado de la evaluación permitir en modo no permisivo " + rdo;
                                return rdo;
                            }
                            );
                    }    
                    params.log += "\nFin evaluación de bloqueos directos";
                }
                    
                //Bloqueo Inverso                
                if (permiteAjax && params.reglasBloqueo.length > 0 ) {
                    params.log += "\nEvaluación de bloqueos inversos";                    
                    if (params.modoPermisivo === true) {
                        params.log += "\nEvaluación en modo permisivo";
                        permiteAjax = params.reglasBloqueo.some (
                            function (cadena) {
                                var rdo =  pasaRegla(object, cadena, self.TIPOS_BLOQUEO.INDIRECTO, object.selectorThis);
                                params.log += "\nResultado de la evaluación permitir en modo permisivo " + rdo ;
                                return rdo;
                            }
                            );
                    } else {
                        permiteAjax = params.reglasBloqueo.every (
                            function (cadena) {
                                var rdo = pasaRegla(object, cadena, self.TIPOS_BLOQUEO.INDIRECTO, object.selectorThis);
                                params.log += "\nResultado de la evaluación permitir en modo no permisivo " + rdo ;
                                return rdo;
                            }
                            );
                    }
                    params.log += "\nFin evaluación de bloqueos inversos";
                }
                
                params.log += "\n----FIN EVALUACIÓN REGLA OBJETO AJAX "+ index +" CON RESULTADO PERMITE = "+ (permiteAjax===true) +" ---";
                if (!permiteAjax) {                    
                    if (!evitarMensajeAlerta) {
                        mostrarMensajeBloqueo(object, params);
                    }
                }
                return !permiteAjax;
            }
            );
        params.log += "\n*** FIN EVALUACIÓN CON ESTADO BLOQUEADO = " + estaBloqueado + " ***";
            
        return estaBloqueado;
    }
    
            
    function pasaRegla(object, cadena, tipoBloqueo, selectorThis) {
        var separador = this.DEFAULT_SEPERADOR_PALABRAS;
        var l = cadena;
        var cb = object.palabraBloqueo;
        if ($.type(cadena) === "object") {
            l = cadena.cadena;
            if (cadena.propiedad !== undefined && object[cadena.propiedad] !== undefined) {
                cb = object[cadena.propiedad]; 
                
            }
        }
        if (object.separador) {
            separador = object.separador;
        }
        var palabraBloqueo = cb.split(separador);
        
        return palabraBloqueo.every (
            function (palabraBloqueo) {                                    
                var permiteAjax = true;
                params.log += "\n*** COMIENZO DE EVALUACIÓN DE CADENA DE REGLAS ***";
                for (var i = 0; i < l.length; i++) {                    
                    params.log += "\nComprobando regla [ palabraBloqueo = " + palabraBloqueo + " ]\t[ separador = " + separador + " ]";
                    var r = l[i]; 
                    if (!r) {
                        params.log += "\tEn la posición [ i = " + i + " ] la regla no está definida y se salta.";
                        continue;
                    } else {
                        params.log += "\t[ valor de permitir = " + (r.permitir===true) + " ]";
                    }
                    var tb = r.tipoBloqueo;
                    params.log += "\t[ tipoBloqueo = " + tb + " ]";
            
                    if (!tb || tb == tipoBloqueo || tb == self.TIPOS_BLOQUEO.BIDIRECCIONAL) {                
                        var matchRegExp = null;
                        var matchSelector = null;
                        
                        if (r.regExp !== undefined) {
                            params.log += "\t[ regExp = " + r.regExp + " ]";
                            if (palabraBloqueo !== undefined) {
                                matchRegExp = palabraBloqueo.match(r.regExp) !== null;
                                if (matchRegExp) {
                                    params.log += "\t[ hay mach de RegExp]";
                                } else {
                                    params.log += "\t[ no hay mach de RegExp]";
                                }
                            } else {
                                matchRegExp = false;
                                params.log +=  "\t[ sin palabraBloqueo no se efectúa el mach de RegExp]";
                            }
                        } else{
                            params.log += "\t[ regExp = vacío ]";
                        }
                
                        
                        if (r.selectorBloqueo !== undefined) {
                            params.log += "\t[ selectorBloqueo = " + r.selectorBloqueo + " ]";                            
                            if (selectorThis !== undefined ) {
                                params.log += "\t[ selectorThis = " + selectorThis + " ]";                                
                                matchSelector = $(r.selectorBloqueo).filter(selectorThis).size() > 0;
                                if (matchSelector) {
                                    params.log += "\t[hay mach de selectorBloqueo]";
                                } else {
                                    params.log += "\t[no hay mach de selectorBloqueo]";
                                }
                            } else {
                                matchSelector = false;
                                params.log +=  "\t[ sin selectorThis no se efectúa el mach de selectorBloque]";                                
                            }
                        } else {
                            params.log += "\t[ selectorBloqueo = vacío ]";
                        }
                
                        if (matchRegExp === true && matchSelector === true ||
                            matchRegExp === null && matchSelector === true || 
                            matchRegExp === true && matchSelector === null ||
                            matchRegExp === null && matchSelector === null && r.permitir !== undefined
                            ) {
                            
                            permiteAjax = r.permitir === true;
                            params.log += "\t[ la regla se aplica con resultado = " + permiteAjax + " ]";
                            
                            if (object.stopPrimeraCoincidencia === true) {
                                params.log += "\t[ stop en primera coincidencia. Se termina de evaluar la cadena  ]";
                                break;
                            }
                        } else {
                            params.log += "\t[ la regla NO se aplica al no haber match ]";
                        }
                    } else {
                        params.log += "\t[ No se evalúa la regla al no coindidir el tipoBloqueo ]\n";
                    }
                    params.log +=  "\t[ por el momento la regla mantiene estado permitir "+permiteAjax +" ]";
                }
                params.log += "\n*** FIN DE EVALUACIÓN DE REGLA ***";                
                return permiteAjax;
            }
            );
    }
    
    function mostrarMensajeBloqueo(object, params) {
        var msg = "Se están esperando datos del servidor."
        if (object && object.descripcion) {
            msg += "<br/><span style='color:green;'>Se está realizando la siguiente operación: " + object.descripcion + "</span>";
        }
        if (params && params.descripcion) {
            msg += "<br/><span style='color:red;'>La operación: " + params.descripcion + " debe esperar.</span>";
        }
        msg += "<br/><br/>Por favor, vuelva a intentarlo dentro de un rato."
        self.verMensaje(msg, params);
        if (object && params) {
            if (params.autoCierreAlertas === undefined) {
                object.cerrarMensaje = true;
            } else {
                object.cerrarMensaje = params.autoCierreAlertas;
            }
        }
    }
    
    
}

MyAjaxRules.prototype.prepararAjax = function(params) {
    
        
    var selectoresEstilo = params.selectoresEstilo;
        
    params.keyEjecucion = (new Date()).getTime(); //Me aseguro de que no hay dos reglas iguales            
    this.myAjaxRulesObjects.push(params);     
    
    this.quitarClases(selectoresEstilo, "valorFinalizar");    
    this.quitarClases(selectoresEstilo, "valorError");    
    this.ponerClases(selectoresEstilo, "valorPreparar");    
    
    this.ponerEventos(selectoresEstilo, "funcionPreparar");    
    
    this.ponerHTML(selectoresEstilo, "valorPreparar");
    
    this.aplicarEstilos (selectoresEstilo, "valorPreparar");
    this.aplicarAtributos (selectoresEstilo, "valorPreparar");

    //this.numProcesos++;
    if (this.debugMode === true) {         
        this.log("numProcesos="+this.myAjaxRulesObjects.length);                
    }
    
}


MyAjaxRules.prototype.finalizarAjax = function(params, conError, mensaje) {        
    
    if (params.yaFinalizado) {
        return;
    } else {
        params.yaFinalizado = true;
    }
    
    
    self = this;    
    
    var selectoresEstilo= params.selectoresEstilo;
    var ocultarModal = params.mensajeMientras;
    
    if (ocultarModal) {        
        self.ocultarMensaje(params);
    }
    
    //alert("aqui1");
    if (params && params.keyEjecucion) {  
        var encontrada = false;
        var i = 0;
        while (!encontrada && i < self.myAjaxRulesObjects.length) {            
            var object = self.myAjaxRulesObjects[i];
            if (object.keyEjecucion === params.keyEjecucion) {
                encontrada = true;
            } else {
                i++;
            }
        } 
        
        if (encontrada) {            
            if (self.myAjaxRulesObjects[i].cerrarMensaje) {
                self.ocultarMensaje(params);                
            }
            self.myAjaxRulesObjects.splice(i, 1);
            //self.numProcesos--;
            if (this.debugMode) {
                this.log("numProcesos="+self.myAjaxRulesObjects.length);
            }
        }
    }
    self.quitarClases(selectoresEstilo, "valorPreparar");    
    if (conError) {
        self.quitarClases(selectoresEstilo, "valorFinalizar");    
        self.ponerClases(selectoresEstilo, "valorError");
        self.ponerHTML(selectoresEstilo, "valorError", "valorFinalizar");                
        self.ponerEventos(selectoresEstilo, "funcionError");
    } else {
        self.quitarClases(selectoresEstilo, "valorError");
        self.ponerClases(selectoresEstilo, "valorFinalizar");            
        self.ponerHTML(selectoresEstilo, "valorFinalizar");        
        self.ponerEventos(selectoresEstilo, "funcionFinalizar");        
    }
    
    
    self.aplicarEstilos (selectoresEstilo, "valorFinalizar", "valorError", conError);
        
    self.aplicarAtributos (selectoresEstilo, "valorFinalizar", "valorError", conError);
    
    
    params.msg = mensaje;
    
    if (mensaje) {
        self.verMensaje(mensaje, params);
    }
    
    
    
    if (typeof params.fnProgreso  === "function") {
        if (!conError) {
            params.readyState = -1;
            params.fnProgreso(params);
            params.esError = false;
        } else {
            params.readyState = 5;
            params.fnProgreso(params);
            params.esError = true;
        }
        window.clearInterval(params.timer);
    }
    
}



MyAjaxRules.prototype.aplicarEstilos = function (selectoresEstilo, valor, valorAlternativo, usarAlternativo) {
    if (selectoresEstilo) {
        for (var i=0; i< selectoresEstilo.length; i++) {
            var s = selectoresEstilo[i];
            if (s && s.selector && s.estilos) {                
                $.each(s.estilos,
                    function (index, estilo) {
                        if (estilo.propiedad) {
                            var v = valor;                            
                            if (usarAlternativo && estilo[valorAlternativo] !== undefined) {
                                v = valorAlternativo;
                            }
                            
                            
                            if (estilo[v] || estilo[v]===0) {
                                $(s.selector).css(estilo.propiedad, estilo[v]);
                            } else {
                                $(s.selector).css(estilo.propiedad, "");
                            }
                            
                        }
                    }
                    );                
            }
        }
    }
}



MyAjaxRules.prototype.aplicarAtributos = function (selectoresEstilo, valor, valorAlternativo, usarAlternativo) {
    if (selectoresEstilo) {
        for (var i=0; i< selectoresEstilo.length; i++) {
            var s = selectoresEstilo[i];
            if (s && s.selector && s.atributos) {                
                $.each(s.atributos,
                    function (index, atributo) {
                        if (atributo.propiedad) {
                            var v = valor;                            
                            if (usarAlternativo && atributo[valorAlternativo] !== undefined) {
                                v = valorAlternativo;
                            }
                            
                            if (atributo[v] || atributo[v]===0) {
                                $(s.selector).attr(atributo.propiedad, atributo[v]);
                            } else {
                                $(s.selector).removeAttr(atributo.propiedad);
                            }
                            
                        }
                    }
                    );                
            }
        }
    }
}

MyAjaxRules.prototype.ponerHTML = function (selectoresEstilo, tipo, tipoAlternativo) {
    if (selectoresEstilo) {
        for (var i=0; i< selectoresEstilo.length; i++) {
            var s = selectoresEstilo[i];            
            if (s && s.selector && s.html) {
                var h = s.html[tipo];
                if (h === undefined) {
                    h = s.html[tipoAlternativo];
                }
                if (!h) {
                    h = "";
                }
                                  
                $(s.selector).html(h);                
                
            }
        }
    }
}

MyAjaxRules.prototype.ponerClases = function (selectoresEstilo, tipo, tipoAlternativo) {
    
    if (selectoresEstilo) {
        for (var i=0; i< selectoresEstilo.length; i++) {
            var s = selectoresEstilo[i];                        
            if (s && s.selector && s.classes) {                
                var t = s.classes[tipo];
                if (t === undefined) {
                    t = s.classes[tipoAlternativo];
                }
                if (t) {
                    $(s.selector).addClass(t);
                //if (t=="categoria_ya_buscada") {
                //  alert($(s.selector).attr("class"));
                //}
                }
            }
        }
    }
}

MyAjaxRules.prototype.ponerEventos = function (selectoresEstilo, valor, valorAlternativo, usarAlternativo) {
    if (selectoresEstilo) {
        for (var i=0; i< selectoresEstilo.length; i++) {
            var s = selectoresEstilo[i];
            if (s && s.selector && s.eventos) {                
                $.each(s.eventos,
                    function (index, evento) {
                        if (evento.tipo) {
                            var v = valor;                            
                            if (usarAlternativo && evento[valorAlternativo] !== undefined) {
                                v = valorAlternativo;
                            }
                            
                            $(s.selector).off(evento.tipo);
                            if (evento[v]) {                                
                                $(s.selector).on(evento.tipo, evento[v]);
                            }
                            
                        }
                    }
                    );                
            }
        }
    }
}

MyAjaxRules.prototype.quitarEventos = function (selectoresEstilo, valor, valorAlternativo, usarAlternativo) {
    if (selectoresEstilo) {
        for (var i=0; i< selectoresEstilo.length; i++) {
            var s = selectoresEstilo[i];
            if (s && s.selector && s.eventos) {                
                $.each(s.eventos,
                    function (index, evento) {
                        if (evento.tipo) {
                            var v = valor;                            
                            if (usarAlternativo && evento[valorAlternativo] !== undefined) {
                                v = valorAlternativo;
                            }
                            
                            //alert(evento[v] + " "+evento.tipo);
                            if (evento[v]) {
                                $(s.selector).off(evento.tipo, evento[v]);
                            }
                            
                        }
                    }
                    );                
            }
        }
    }
}


MyAjaxRules.prototype.quitarClases = function (selectoresEstilo, tipo) {
    if (selectoresEstilo) {
        for (var i=0; i< selectoresEstilo.length; i++) {
            var s = selectoresEstilo[i];
            if (s && s.selector && s.classes && s.classes[tipo]) {                
                $(s.selector).removeClass(s.classes[tipo]);
            }
        }
    }
}

MyAjaxRules.prototype.preEjecutarAJAX = function (params) {     
    
    if (!params || typeof params != "object") {
        this.verMensaje("No ha pasado ningún objeto como parámetro", params);
        return;
    }
    
    params.tiempoComienzo = (new Date()).getTime();
    
            
    if (params.reglasBloqueo === undefined) {
        params.reglasBloqueo = new Array();
    }
    
    if (params.palabraBloqueo === undefined) {                
        params.palabraBloqueo = this.DEFAULT_PALABRA_BLOQUEO;        
    }
    
    if (params.ajaxTimeout) {
        if (params.ajaxTimeout < this.MAX_AJAX_TIMEOUT) {
            params.ajaxTimeout = params.ajaxTimeout;
        } else {
            params.ajaxTimeout = this.MAX_AJAX_TIMEOUT;
        }
    } else {
        params.ajaxTimeout = this.MAX_AJAX_TIMEOUT;
    }
    
    var  puedoEjecutar = this.puedoEjecutarAjax(params, false);
    
    
    if (this.debugMode === true) {         
        this.log(params.log);                
    }
    
    params.log = "";
    
    
    if (!puedoEjecutar) { 
        return false;
    } else {    
        this.prepararAjax(params);
        if (typeof params.fnProgreso  === "function") {            
                   
            var interval = params.ajaxTimeout/10;
            if (interval > 1000) {
                interval = 1000;
            } else if (interval < 500) {
                interval = 500;
            }
            params.timer = window.setInterval(params.fnProgreso, interval , params);
        }
        
        if (params.mensajeMientras) {                
            this.verMensajeModal(params.mensajeMientras, params);
        }
        
        
        return true;
    }
   
    
}

MyAjaxRules.prototype.ejecutarFakeAJAX = function(params) {
    var self = this;
    
    if (!this.preEjecutarAJAX (params)) {
        return;
    }
    
    
    var mensaje;   
    if (typeof params.fnProgreso  === "function") {                    
        params.fnProgreso(params);
    }
    if (params.funcionRespuesta) {
        if (params.delayFake === undefined) {
            finalizarFake();                      
        } else {
            window.setTimeout(finalizarFake, params.delayFake);                            
        }
    }
    
    
    function finalizarFake() {
        params.funcionRespuesta(params.datosCallback, params); 
        if (params.mensajeExito) {
            mensaje = params.mensajeExito;
        } else {
            mensaje = params.msg;
        }
    
        self.finalizarAjax(params, params.esError === true , mensaje);
    }
    
    
    
    
    
}


MyAjaxRules.prototype.ejecutarAJAX = function (params) {     
    
    if (!this.preEjecutarAJAX (params)) {
        return;
    }
    
    var self = this;
    try {        
        
        var ajax = new XMLHttpRequest();
        params.readyState = ajax.readyState;
        
        
        ajax.onreadystatechange = function() {            
               
            if (typeof params.fnProgreso  === "function") {            
                params.readyState = ajax.readyState;
                params.fnProgreso(params);
            }
            if (ajax.readyState == 4) { 
                params.tiempoFinal = (new Date()).getTime();    
                var tiempoEjecucion = params.tiempoFinal - params.tiempoComienzo;
                //alert(tiempoEjecucion);
                if (params.tiempoMinimo > 0 && tiempoEjecucion < params.tiempoMinimo) {
                    window.setTimeout(post_ejecutarAJAX, params.tiempoMinimo - tiempoEjecucion);
                } else {
                    post_ejecutarAJAX();
                }
            }
        }
    
        if (!params.method) {
            self.finalizarAjax(params, true,"No se ha especificado la propiedad 'method'");
        } else {
            switch (params.method.toUpperCase()) {
                case "GET":
                    doGet();                            
                    break;
                case "POST":
                    doPost();
                    break;
                default:
                    self.finalizarAjax(params, true,"Method incorrecto: "+params.method);
            }
    
    
    
            var timeout = setTimeout(function() {        
                if (ajax.readyState < 2) {                    
                    var msg = "El servidor está tardando mucho tiempo en responder.<br/>Se aborta la petición"
                    if (params.descripcion) {
                        msg += ": <span style='color:red;'>" + params.descripcion + "</span>";
                    } else {
                        msg += ".";
                    } 
                    params.msg = msg;
                    params.esError = true;
                    ajax.abort();   
                    self.finalizarAjax(params, true, msg);
                    
                }       
            }, params.ajaxTimeout);
    
        }
    } catch (e) {
        self.finalizarAjax(params, true, "Se ha producido el siguiente error "+e);
    }
    
    function doGet() {
        var urlFinal = params.url;    
        if (params.JSObject) {
            urlFinal += "?datos=" + encodeURIComponent(JSON.stringify(params.JSObject));
        }
        
        ajax.open('GET', urlFinal , true);
        ajax.setRequestHeader('Content-Type', 'application/json;charset=utf-8');
        ajax.send(null);
        
    }
    
    function doPost() {
        ajax.open('POST', params.url , true);
        ajax.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded;charset=utf-8');        
        ajax.send("datos="+JSON.stringify(params.JSObject));
    }
    
    function post_ejecutarAJAX() {
                
        if ( (ajax.status >= 200 && ajax.status < 300) 
            || (ajax.status == 304) ) {                    
                
            params.ajaxResponse = ajax.responseText;
                    
            if (params.funcionRespuesta) {
                params.funcionRespuesta(ajax.responseText, params.datosCallback, params);                        
            }
            if (params.mensajeExito) {
                mensaje = params.mensajeExito;
            } else {
                mensaje = params.msg;
            }
            self.finalizarAjax(params, params.esError === true , mensaje);
                
        } else { 
            if (!(params.esError === true)) {            
                self.finalizarAjax(params, true, "Respuesta del servidor incorrecta ("+ajax.status+"). Revise la url");
            }
                
        }
    }
    
    
    
}

MyAjaxRules.prototype.verMensaje = function (msg, params) { 
    if (this.debugMode === true) {
        msg = this.quitarEtiquetasHTML(msg);
    }
    if (params && typeof  params.fnVerMensaje  === "function") {        
        params.fnVerMensaje(msg);        
    } else if (typeof this.fnVerMensaje  === "function") {
        this.fnVerMensaje(msg);        
    } else {
        alert(this.quitarEtiquetasHTML(msg));
    }
}

MyAjaxRules.prototype.verMensajeModal = function (msg, params) {    
    if (this.debugMode === true) {
        msg = this.quitarEtiquetasHTML(msg);
    }
    if (params && typeof params.fnVerMensajeModal  === "function") {
        params.fnVerMensajeModal(msg);
    } else if (typeof this.fnVerMensajeModal  === "function") {
        this.fnVerMensajeModal(msg);        
    } else {
        alert(this.quitarEtiquetasHTML(msg));
    }
}

MyAjaxRules.prototype.ocultarMensaje = function (params) {
    if (params && typeof params.fnOcultarMensaje  === "function") {
        params.fnOcultarMensaje();
    } else if (typeof this.fnOcultarMensaje  === "function") {
        this.fnOcultarMensaje();
    }
}

MyAjaxRules.prototype.log = function (msg, params) {     
    if (params && typeof params.fnLog  === "function") {
        params.fnLog(msg);
    } else if (typeof this.fnLog  === "function") {
        this.fnLog(msg);        
    } else {
        console.log(this.quitarEtiquetasHTML(msg));
    }
}



MyAjaxRules.prototype.quitarEtiquetasHTML = function (msg) {        
    return msg.replace(/<[/ ]*(br|span|div)[/ ]*>/ig,"\n").replace(/<[^>]*>/ig,"").replace(/\n+/,"\n");
}
